home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2008 April / PCgo 2008-04 (DVD).iso / interface / contents / demoversionen_3846 / 13664 / files / Data1.cab / events.cpp1 < prev    next >
Encoding:
Text File  |  2001-10-16  |  24.4 KB  |  799 lines
  1. /******************************************************************/
  2. /*                                                                */
  3. /*                      TurboCAD for Windows                      */
  4. /*                   Copyright (c) 1993 - 2001                    */
  5. /*             International Microcomputer Software, Inc.         */
  6. /*                            (IMSI)                              */
  7. /*                      All rights reserved.                      */
  8. /*                                                                */
  9. /******************************************************************/
  10. // TCEvents.cpp : Defines the class behaviors for the application.
  11. // This sample demonstrate how handle TurboCAD's events
  12.  
  13. #include "stdafx.h"
  14. #include "Events.h"
  15. #include "EventDlg.h"
  16.  
  17. #ifdef _DEBUG
  18. #define new DEBUG_NEW
  19. #undef THIS_FILE
  20. static char THIS_FILE[] = __FILE__;
  21. #endif
  22.  
  23. // Some IIDs from imsigx.i_c
  24. const IID LIBID_IMSIGXLib = {0x6A481400,0xE531,0x11CF,{0xA1,0x15,0x00,0xA0,0x24,0x15,0x8D,0xAF}};
  25. const IID IID_PickResult = {0x6A481123,0xE531,0x11CF,{0xA1,0x15,0x00,0xA0,0x24,0x15,0x8D,0xAF}};
  26. const IID IID_Tool = {0x6A48112C,0xE531,0x11CF,{0xA1,0x15,0x00,0xA0,0x24,0x15,0x8D,0xAF}};
  27.  
  28. ////////////////////////////////////////////////////////////////////////////
  29. // CTCEventsApp
  30.  
  31. BEGIN_MESSAGE_MAP(CTCEventsApp, CWinApp)
  32.     //{{AFX_MSG_MAP(CTCEventsApp)
  33.         // NOTE - the ClassWizard will add and remove mapping macros here.
  34.         //    DO NOT EDIT what you see in these blocks of generated code!
  35.     //}}AFX_MSG
  36.     ON_COMMAND(ID_HELP, CWinApp::OnHelp)
  37. END_MESSAGE_MAP()
  38.  
  39. BEGIN_DISPATCH_MAP(CTCEventsApp, CWinApp)
  40.     //{{AFX_DISPATCH_MAP(CTCEventsApp)
  41.     DISP_FUNCTION(CTCEventsApp, "BeforeExit", BeforeExit, VT_EMPTY, VTS_DISPATCH VTS_PBOOL)
  42.     DISP_FUNCTION(CTCEventsApp, "DrawingNew", DrawingNew, VT_EMPTY, VTS_DISPATCH)
  43.     DISP_FUNCTION(CTCEventsApp, "DrawingOpen", DrawingOpen, VT_EMPTY, VTS_DISPATCH)
  44.     DISP_FUNCTION(CTCEventsApp, "DrawingActivate", DrawingActivate, VT_EMPTY, VTS_DISPATCH)
  45.     DISP_FUNCTION(CTCEventsApp, "DrawingDeactivate", DrawingDeactivate, VT_EMPTY, VTS_DISPATCH)
  46.     DISP_FUNCTION(CTCEventsApp, "DrawingBeforeClose", DrawingBeforeClose, VT_EMPTY, VTS_DISPATCH VTS_PBOOL)
  47.     DISP_FUNCTION(CTCEventsApp, "DrawingBeforeSave", DrawingBeforeSave, VT_EMPTY, VTS_DISPATCH VTS_PBOOL VTS_PBOOL)
  48.     DISP_FUNCTION(CTCEventsApp, "DrawingAfterSave", DrawingAfterSave, VT_EMPTY, VTS_DISPATCH)
  49.     DISP_FUNCTION(CTCEventsApp, "WindowResize", WindowResize, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH)
  50.     DISP_FUNCTION(CTCEventsApp, "WindowActivate", WindowActivate, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH)
  51.     DISP_FUNCTION(CTCEventsApp, "WindowDeactivate", WindowDeactivate, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH)
  52.     DISP_FUNCTION(CTCEventsApp, "MouseDown", MouseDown, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_I2 VTS_I4 VTS_I4 VTS_I4 VTS_PBOOL)
  53.     DISP_FUNCTION(CTCEventsApp, "MouseUp", MouseUp, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_I2 VTS_I4 VTS_I4 VTS_I4 VTS_PBOOL)
  54.     DISP_FUNCTION(CTCEventsApp, "MouseMove", MouseMove, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_I4 VTS_I4 VTS_I4 VTS_PBOOL)
  55.     DISP_FUNCTION(CTCEventsApp, "BeforeDoubleClick", BeforeDoubleClick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_PBOOL)
  56.     DISP_FUNCTION(CTCEventsApp, "BeforeRightClick", BeforeRightClick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_PBOOL)
  57.     DISP_FUNCTION(CTCEventsApp, "SelectionChange", SelectionChange, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH)
  58.     DISP_FUNCTION(CTCEventsApp, "CommandBarControlHit", CommandBarControlHit, VT_EMPTY, VTS_DISPATCH VTS_PBOOL)
  59.     DISP_FUNCTION(CTCEventsApp, "CommandBarControlStatus", CommandBarControlStatus, VT_EMPTY, VTS_DISPATCH)
  60.     DISP_FUNCTION(CTCEventsApp, "RunTool", RunTool, VT_EMPTY, VTS_DISPATCH)
  61.     DISP_FUNCTION(CTCEventsApp, "PointSnapped", PointSnapped, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_I4 VTS_I4 VTS_DISPATCH VTS_DISPATCH)
  62.     DISP_FUNCTION(CTCEventsApp, "PointPick", PointPick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_BOOL)
  63.     DISP_FUNCTION(CTCEventsApp, "RectanglePick", RectanglePick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_BOOL)
  64.     DISP_FUNCTION(CTCEventsApp, "PolygonPick", PolygonPick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_BOOL)
  65.     DISP_FUNCTION(CTCEventsApp, "ViewBeforeRedraw", ViewBeforeRedraw, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH)
  66.     DISP_FUNCTION(CTCEventsApp, "ViewAfterRedraw", ViewAfterRedraw, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH)
  67.     DISP_FUNCTION(CTCEventsApp, "VirtualIntersectionPick", VirtualIntersectionPick, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_BOOL)
  68.     DISP_FUNCTION(CTCEventsApp, "CommandBarControlDone", CommandBarControlDone, VT_EMPTY, VTS_DISPATCH)
  69.     DISP_FUNCTION(CTCEventsApp, "Drop", Drop, VT_EMPTY, VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH VTS_DISPATCH)
  70.     //}}AFX_DISPATCH_MAP
  71. END_DISPATCH_MAP()
  72.  
  73. // Note: we add support for IID_IAppEvents to support typesafe binding
  74. //  from VBA.  This IID must match the GUID that is attached to the
  75. //  dispinterface in the .ODL file.
  76.  
  77. // {6A481301-E531-11CF-A115-00A024158DAF}
  78. static const IID IID_IAppEvents =
  79. { 0x6A481301, 0xE531, 0x11CF, { 0xA1, 0x15, 0x0, 0xA0, 0x24, 0x15, 0x8D, 0xAF } };
  80.  
  81. BEGIN_INTERFACE_MAP(CTCEventsApp, CWinApp)
  82.     INTERFACE_PART(CTCEventsApp, IID_IAppEvents, Dispatch)
  83. END_INTERFACE_MAP()
  84.  
  85. /////////////////////////////////////////////////////////////////////////////
  86. // CTCEventsApp construction
  87.  
  88. CTCEventsApp::CTCEventsApp()
  89. {
  90.     // TODO: add construction code here,
  91.     // Place all significant initialization in InitInstance
  92. }
  93.  
  94. /////////////////////////////////////////////////////////////////////////////
  95. // The one and only CTCEventsApp object
  96.  
  97. CTCEventsApp theApp;
  98.  
  99. /////////////////////////////////////////////////////////////////////////////
  100. // CTCEventsApp initialization
  101.  
  102. BOOL CTCEventsApp::InitInstance()
  103. {
  104.     // Initialize OLE libraries
  105.     if (!AfxOleInit())
  106.     {
  107.         AfxMessageBox(IDP_OLE_INIT_FAILED);
  108.         return FALSE;
  109.     }
  110.  
  111.     // Standard initialization
  112.     // If you are not using these features and wish to reduce the size
  113.     //  of your final executable, you should remove from the following
  114.     //  the specific initialization routines you do not need.
  115.  
  116. #ifdef _AFXDLL
  117.     Enable3dControls();            // Call this when using MFC in a shared DLL
  118. #else
  119.     Enable3dControlsStatic();    // Call this when linking to MFC statically
  120. #endif
  121.  
  122.     // Parse the command line to see if launched as OLE server
  123.     if (RunEmbedded() || RunAutomated())
  124.     {
  125.         // Register all OLE server (factories) as running.  This enables the
  126.         //  OLE libraries to create objects from other applications.
  127.         COleTemplateServer::RegisterAll();
  128.  
  129.         // Application was run with /Embedding or /Automation.  Don't show the
  130.         //  main window in this case.
  131.         return TRUE;
  132.     }
  133.  
  134.     // Hook up IDispatch
  135.     EnableAutomation();
  136.  
  137.     // When a server application is launched stand-alone, it is a good idea
  138.     //  to update the system registry in case it has been damaged.
  139.     COleObjectFactory::UpdateRegistryAll();
  140.  
  141.     CTCEventsDlg dlg;
  142.     m_pMainWnd = &dlg;
  143.     int nResponse = dlg.DoModal();
  144.     if (nResponse == IDOK)
  145.     {
  146.         // TODO: Place code here to handle when the dialog is
  147.         //  dismissed with OK
  148.     }
  149.     else if (nResponse == IDCANCEL)
  150.     {
  151.         // TODO: Place code here to handle when the dialog is
  152.         //  dismissed with Cancel
  153.     }
  154.  
  155.     // Since the dialog has been closed, return FALSE so that we exit the
  156.     //  application, rather than start the application's message pump.
  157.     return FALSE;
  158. }
  159.  
  160. // Let's show some useful information also...
  161. // Run through the pick result object and report what's in it.
  162.  
  163. static void ShowGraphicInfo(CString& str, PickResult *pres)
  164. {
  165.     if (pres)
  166.     {
  167.         long lCount = 0;
  168.         pres->get_Count(&lCount);
  169.         char* line = str.GetBuffer(2000);
  170.         wsprintf(line, "%ld Graphics:\r\n", lCount);
  171.  
  172.         for (long l = 0; l < lCount; ++l)
  173.         {
  174.             char sline[30];
  175.             PickEntry *pentry = 0;
  176.             COleVariant vindex(l);
  177.             pres->get_Item(&vindex, &pentry);
  178.             if (pentry)
  179.             {
  180.                 IGraphic *pgr;
  181.                 pentry->get_Graphic(&pgr);
  182.                 if (pgr)
  183.                 {
  184.                     ImsiGraphicType type;
  185.                     if (SUCCEEDED(pgr->get_TypeByValue(&type)))
  186.                     {
  187.                         char *unk = "Unknown";
  188.                         char *gname[] = {unk, unk, "Arc","Mesh","Viewport",unk,"Text",
  189.                             unk,unk,unk,unk,"Polyline",unk,unk,"Data","Ole Object",
  190.                             "Extended Data","Insert","Surface"};
  191.  
  192.                         wsprintf(sline, "  %s\r\n", gname[type]);
  193.                     }
  194.                     pgr->Release();
  195.                 }
  196.                 pentry->Release();
  197.             }
  198.             strcat(line, sline);
  199.         }
  200.         str.ReleaseBuffer();
  201.     }
  202. }
  203.  
  204. /////////////////////////////////////////////////////////////////////////////
  205. // CTCEventsApp commands
  206.  
  207. // All we do on an event is post a string to the edit box on the main dialog.
  208.  
  209. void CTCEventsApp::BeforeExit(LPDISPATCH TheApp, BOOL FAR* Cancel)
  210. {
  211.     GetDialog()->AppendText("BeforeExit\r\n");
  212. }
  213.  
  214. void CTCEventsApp::DrawingNew(LPDISPATCH WhichDrawing)
  215. {
  216.     GetDialog()->AppendText("DrawingNew\r\n");
  217. }
  218.  
  219. void CTCEventsApp::DrawingOpen(LPDISPATCH WhichDrawing)
  220. {
  221.     GetDialog()->AppendText("DrawingOpen\r\n");
  222. }
  223.  
  224. void CTCEventsApp::DrawingActivate(LPDISPATCH WhichDrawing)
  225. {
  226.     GetDialog()->AppendText("DrawingActivate\r\n");
  227. }
  228.  
  229. void CTCEventsApp::DrawingDeactivate(LPDISPATCH WhichDrawing)
  230. {
  231.     GetDialog()->AppendText("DrawingDeactivate\r\n");
  232. }
  233.  
  234. void CTCEventsApp::DrawingBeforeClose(LPDISPATCH WhichDrawing, BOOL FAR* Cancel)
  235. {
  236.     GetDialog()->AppendText("DrawingBeforeClose\r\n");
  237. }
  238.  
  239. void CTCEventsApp::DrawingBeforeSave(LPDISPATCH WhichDrawing, BOOL FAR* SaveAs, BOOL FAR* Cancel)
  240. {
  241.     GetDialog()->AppendText("DrawingBeforeSave\r\n");
  242. }
  243. void CTCEventsApp::DrawingAfterSave(LPDISPATCH WhichDrawing)
  244. {
  245.     GetDialog()->AppendText("DrawingAfterSave\r\n");
  246. }
  247.  
  248. void CTCEventsApp::WindowResize(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow)
  249. {
  250.     GetDialog()->AppendText("WindowResize\r\n");
  251. }
  252.  
  253. void CTCEventsApp::WindowActivate(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow)
  254. {
  255.     GetDialog()->AppendText("WindowActivate\r\n");
  256. }
  257.  
  258. void CTCEventsApp::WindowDeactivate(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow)
  259. {
  260.     GetDialog()->AppendText("WindowDeactivate\r\n");
  261. }
  262.  
  263. void CTCEventsApp::MouseDown(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, short Button, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  264. {
  265.     *pbCancel = FALSE;
  266.     GetDialog()->AppendText("MouseDown\r\n");
  267. }
  268.  
  269. void CTCEventsApp::MouseUp(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, short Button, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  270. {
  271.     *pbCancel = FALSE;
  272.     GetDialog()->AppendText("MouseUp\r\n");
  273. }
  274.  
  275. void CTCEventsApp::MouseMove(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  276. {
  277.     *pbCancel = FALSE;
  278.     GetDialog()->AppendText("MouseMove\r\n");
  279. }
  280.  
  281. void CTCEventsApp::BeforeDoubleClick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, LPDISPATCH Sel, BOOL FAR* Cancel)
  282. {
  283.     GetDialog()->AppendText("BeforeDoubleClick\r\n");
  284. }
  285.  
  286. void CTCEventsApp::BeforeRightClick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, LPDISPATCH Sel, BOOL FAR* Cancel)
  287. {
  288.     GetDialog()->AppendText("BeforeRightClick\r\n");
  289. }
  290.  
  291. void CTCEventsApp::SelectionChange(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, LPDISPATCH Sel)
  292. {
  293.     GetDialog()->AppendText("SelectionChange\r\n");
  294. }
  295.  
  296. void CTCEventsApp::CommandBarControlHit(LPDISPATCH WhichControl, BOOL FAR* Cancel)
  297. {
  298.     GetDialog()->AppendText("CommandBarControlHit\r\n");
  299. }
  300.  
  301. void CTCEventsApp::CommandBarControlStatus(LPDISPATCH WhichControl)
  302. {
  303.     GetDialog()->AppendText("CommandBarControlStatus\r\n");
  304. }
  305.  
  306. void CTCEventsApp::RunTool(LPDISPATCH WhichTool)
  307. {
  308.     // Report on the name of the tool that's running
  309.     CString toolName;
  310.     if (WhichTool == NULL)
  311.     {
  312.         toolName = "<NULL>";
  313.     }
  314.     else
  315.     {
  316.         Tool* pTool = NULL;
  317.         HRESULT hRes = WhichTool->QueryInterface(IID_Tool, (void**)&pTool);
  318.         if (SUCCEEDED(hRes))
  319.         {
  320.             BSTR name = NULL;
  321.             hRes = pTool->get_CommandName(0, &name);
  322.             if (SUCCEEDED(hRes))
  323.             {
  324.                 toolName = name;
  325.                 ::SysFreeString(name);
  326.             }
  327.             else
  328.             {
  329.                 toolName = "<No Name>";
  330.             }
  331.             pTool->Release();
  332.         }
  333.         else
  334.         {
  335.             toolName = "<No IID_Tool>";
  336.         }
  337.     }
  338.     toolName += "\r\n";
  339.  
  340.     GetDialog()->AppendText("RunTool: ");
  341.     GetDialog()->AppendText(toolName);
  342. }
  343.  
  344. void CTCEventsApp::PointSnapped(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, long XScreen, long YScreen, LPDISPATCH PointRaw, LPDISPATCH PointSnapped)
  345. {
  346.     GetDialog()->AppendText("PointSnapped\r\n");
  347. }
  348.  
  349. void CTCEventsApp::PointPick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH Result, BOOL PickWasCanceled)
  350. {
  351.     GetDialog()->AppendText("PointPick\r\n");
  352.  
  353.     // Let's show some useful information also...
  354.     PickResult* pRes = NULL;
  355.     HRESULT hRes = Result->QueryInterface(IID_PickResult, (void**)&pRes);
  356.     if (pRes != NULL)
  357.     {
  358.         CString str;
  359.         ShowGraphicInfo(str, pRes);
  360.         GetDialog()->AppendText(str);
  361.         pRes->Release();
  362.     }
  363. }
  364.  
  365. void CTCEventsApp::RectanglePick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH Result, BOOL PickWasCanceled)
  366. {
  367.     GetDialog()->AppendText("RectanglePick\r\n");
  368.  
  369.     // Let's show some useful information also...
  370.     PickResult* pRes = NULL;
  371.     HRESULT hRes = Result->QueryInterface(IID_PickResult, (void**)&pRes);
  372.     if (pRes != NULL)
  373.     {
  374.         CString str;
  375.         ShowGraphicInfo(str, pRes);
  376.         GetDialog()->AppendText(str);
  377.         pRes->Release();
  378.     }
  379. }
  380.  
  381. void CTCEventsApp::PolygonPick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH Result, BOOL PickWasCanceled)
  382. {
  383.     GetDialog()->AppendText("PolygonPick\r\n");
  384. }
  385.  
  386.  
  387. void CTCEventsApp::ViewBeforeRedraw(LPDISPATCH WhichDrawing, LPDISPATCH WhichView)
  388. {
  389.     GetDialog()->AppendText("ViewBeforeRedraw\r\n");
  390. }
  391.  
  392. void CTCEventsApp::ViewAfterRedraw(LPDISPATCH WhichDrawing, LPDISPATCH WhichView)
  393. {
  394.     GetDialog()->AppendText("ViewAfterRedraw\r\n");
  395. }
  396.  
  397. void CTCEventsApp::VirtualIntersectionPick(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH Pick, BOOL WasCanceled) 
  398. {
  399.     GetDialog()->AppendText("VirtualIntersectionPick\r\n");
  400. }
  401.  
  402. void CTCEventsApp::CommandBarControlDone(LPDISPATCH WhichControl) 
  403. {
  404.     GetDialog()->AppendText("CommandBarControlDone\r\n");
  405. }
  406.  
  407. void CTCEventsApp::Drop(LPDISPATCH WhichDrawing, LPDISPATCH WhichView, LPDISPATCH WhichWindow, LPDISPATCH Sel) 
  408. {
  409.     GetDialog()->AppendText("Drop\r\n");
  410. }
  411.  
  412. // DUAL_SUPPORT_START
  413. // The rest of this file is boilerplate dual interface stuff.  We use macros from MfcDual.h
  414. // and just wrap all of our implementation functions in TRY/CATCH blocks.
  415.  
  416. // delegate standard IDispatch methods to MFC IDispatch implementation
  417. DELEGATE_DUAL_INTERFACE(CTCEventsApp, AppEvents)
  418.  
  419. // Our method and property functions can generally just
  420. // delegate back to the methods we generated using 
  421. // ClassWizard. However, if we set up properties to 
  422. // access variables directly, we will need to write the
  423. // code to get/put the value into the variable.
  424.  
  425. STDMETHODIMP CTCEventsApp::XAppEvents::BeforeExit(IApplication* TheApp, IMSI_BOOL* Cancel)
  426. {
  427.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  428.  
  429.     TRY_DUAL(IID_IAppEvents)
  430.     {
  431.         // Need to convert between boolean types
  432.         BOOL bCancel = *Cancel;
  433.         pThis->BeforeExit(TheApp, &bCancel);
  434.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  435.         return S_OK;
  436.     }
  437.     CATCH_ALL_DUAL
  438. }
  439.  
  440. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingNew(IDrawing* WhichDrawing)
  441. {
  442.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  443.  
  444.     TRY_DUAL(IID_IAppEvents)
  445.     {
  446.         pThis->DrawingNew(WhichDrawing);
  447.         return S_OK;
  448.     }
  449.     CATCH_ALL_DUAL
  450. }
  451.  
  452. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingOpen(IDrawing* WhichDrawing)
  453. {
  454.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  455.  
  456.     TRY_DUAL(IID_IAppEvents)
  457.     {
  458.         pThis->DrawingOpen(WhichDrawing);
  459.         return S_OK;
  460.     }
  461.     CATCH_ALL_DUAL
  462. }
  463.  
  464. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingActivate(IDrawing* WhichDrawing)
  465. {
  466.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  467.  
  468.     TRY_DUAL(IID_IAppEvents)
  469.     {
  470.         pThis->DrawingActivate(WhichDrawing);
  471.         return S_OK;
  472.     }
  473.     CATCH_ALL_DUAL
  474. }
  475.  
  476. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingDeactivate(IDrawing* WhichDrawing)
  477. {
  478.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  479.  
  480.     TRY_DUAL(IID_IAppEvents)
  481.     {
  482.         pThis->DrawingDeactivate(WhichDrawing);
  483.         return S_OK;
  484.     }
  485.     CATCH_ALL_DUAL
  486. }
  487.  
  488. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingBeforeClose(IDrawing* WhichDrawing, IMSI_BOOL* Cancel)
  489. {
  490.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  491.  
  492.     TRY_DUAL(IID_IAppEvents)
  493.     {
  494.         // Need to convert between boolean types
  495.         BOOL bCancel = *Cancel;
  496.         pThis->DrawingBeforeClose(WhichDrawing, &bCancel);
  497.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  498.         return S_OK;
  499.     }
  500.     CATCH_ALL_DUAL
  501. }
  502.  
  503. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingBeforeSave(IDrawing* WhichDrawing, IMSI_BOOL* SaveAs, IMSI_BOOL* Cancel)
  504. {
  505.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  506.  
  507.     TRY_DUAL(IID_IAppEvents)
  508.     {
  509.         // Need to convert between boolean types
  510.         BOOL bSaveAs = *SaveAs;
  511.         BOOL bCancel = *Cancel;
  512.         pThis->DrawingBeforeSave(WhichDrawing, &bSaveAs, &bCancel);
  513.         *SaveAs = bSaveAs ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  514.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  515.         return S_OK;
  516.     }
  517.     CATCH_ALL_DUAL
  518. }
  519. STDMETHODIMP CTCEventsApp::XAppEvents::DrawingAfterSave(IDrawing* WhichDrawing)
  520. {
  521.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  522.  
  523.     TRY_DUAL(IID_IAppEvents)
  524.     {
  525.         pThis->DrawingAfterSave(WhichDrawing);
  526.         return S_OK;
  527.     }
  528.     CATCH_ALL_DUAL
  529. }
  530.  
  531. STDMETHODIMP CTCEventsApp::XAppEvents::WindowResize(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow)
  532. {
  533.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  534.  
  535.     TRY_DUAL(IID_IAppEvents)
  536.     {
  537.         pThis->WindowResize(WhichDrawing, WhichView, WhichWindow);
  538.         return S_OK;
  539.     }
  540.     CATCH_ALL_DUAL
  541. }
  542.  
  543. STDMETHODIMP CTCEventsApp::XAppEvents::WindowActivate(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow)
  544. {
  545.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  546.  
  547.     TRY_DUAL(IID_IAppEvents)
  548.     {
  549.         pThis->WindowActivate(WhichDrawing, WhichView, WhichWindow);
  550.         return S_OK;
  551.     }
  552.     CATCH_ALL_DUAL
  553. }
  554.  
  555. STDMETHODIMP CTCEventsApp::XAppEvents::WindowDeactivate(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow)
  556. {
  557.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  558.  
  559.     TRY_DUAL(IID_IAppEvents)
  560.     {
  561.         pThis->WindowDeactivate(WhichDrawing, WhichView, WhichWindow);
  562.         return S_OK;
  563.     }
  564.     CATCH_ALL_DUAL
  565. }
  566.  
  567. STDMETHODIMP CTCEventsApp::XAppEvents::MouseDown(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, ImsiMouseButton Button, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  568. {
  569.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  570.  
  571.     TRY_DUAL(IID_IAppEvents)
  572.     {
  573.         pThis->MouseDown(WhichDrawing, WhichView, WhichWindow, Button, Shift, X, Y, pbCancel);
  574.         return S_OK;
  575.     }
  576.     CATCH_ALL_DUAL
  577. }
  578.  
  579. STDMETHODIMP CTCEventsApp::XAppEvents::MouseUp(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, ImsiMouseButton Button, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  580. {
  581.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  582.  
  583.     TRY_DUAL(IID_IAppEvents)
  584.     {
  585.         pThis->MouseUp(WhichDrawing, WhichView, WhichWindow, Button, Shift, X, Y, pbCancel);
  586.         return S_OK;
  587.     }
  588.     CATCH_ALL_DUAL
  589. }
  590.  
  591. STDMETHODIMP CTCEventsApp::XAppEvents::MouseMove(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, long Shift, long X, long Y, IMSI_BOOL* pbCancel)
  592. {
  593.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  594.  
  595.     TRY_DUAL(IID_IAppEvents)
  596.     {
  597.         pThis->MouseMove(WhichDrawing, WhichView, WhichWindow, Shift, X, Y, pbCancel);
  598.         return S_OK;
  599.     }
  600.     CATCH_ALL_DUAL
  601. }
  602.  
  603. STDMETHODIMP CTCEventsApp::XAppEvents::BeforeDoubleClick(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, Selection* Sel, IMSI_BOOL* Cancel)
  604. {
  605.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  606.  
  607.     TRY_DUAL(IID_IAppEvents)
  608.     {
  609.         // Need to convert between boolean types
  610.         BOOL bCancel = *Cancel;
  611.         pThis->BeforeDoubleClick(WhichDrawing, WhichView, WhichWindow, Sel, &bCancel);
  612.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  613.         return S_OK;
  614.     }
  615.     CATCH_ALL_DUAL
  616. }
  617.  
  618. STDMETHODIMP CTCEventsApp::XAppEvents::BeforeRightClick(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, Selection* Sel, IMSI_BOOL* Cancel)
  619. {
  620.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  621.  
  622.     TRY_DUAL(IID_IAppEvents)
  623.     {
  624.         // Need to convert between boolean types
  625.         BOOL bCancel = *Cancel;
  626.         pThis->BeforeRightClick(WhichDrawing, WhichView, WhichWindow, Sel, &bCancel);
  627.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  628.         return S_OK;
  629.     }
  630.     CATCH_ALL_DUAL
  631. }
  632.  
  633. STDMETHODIMP CTCEventsApp::XAppEvents::SelectionChange(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, Selection* Sel)
  634. {
  635.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  636.  
  637.     TRY_DUAL(IID_IAppEvents)
  638.     {
  639.         pThis->SelectionChange(WhichDrawing, WhichView, WhichWindow, Sel);
  640.         return S_OK;
  641.     }
  642.     CATCH_ALL_DUAL
  643. }
  644.  
  645. STDMETHODIMP CTCEventsApp::XAppEvents::CommandBarControlHit(CommandBarControl* WhichControl, IMSI_BOOL* Cancel)
  646. {
  647.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  648.  
  649.     TRY_DUAL(IID_IAppEvents)
  650.     {
  651.         // Need to convert between boolean types
  652.         BOOL bCancel = *Cancel;
  653.         pThis->CommandBarControlHit(WhichControl, &bCancel);
  654.         *Cancel = bCancel ? (IMSI_BOOL)-1 : (IMSI_BOOL)0;
  655.         return S_OK;
  656.     }
  657.     CATCH_ALL_DUAL
  658. }
  659.  
  660. STDMETHODIMP CTCEventsApp::XAppEvents::CommandBarControlStatus(CommandBarControl* WhichControl)
  661. {
  662.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  663.  
  664.     TRY_DUAL(IID_IAppEvents)
  665.     {
  666.         pThis->CommandBarControlStatus(WhichControl);
  667.         return S_OK;
  668.     }
  669.     CATCH_ALL_DUAL
  670. }
  671.  
  672. STDMETHODIMP CTCEventsApp::XAppEvents::RunTool(Tool* WhichTool)
  673. {
  674.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  675.  
  676.     TRY_DUAL(IID_IAppEvents)
  677.     {
  678.         pThis->RunTool(WhichTool);
  679.         return S_OK;
  680.     }
  681.     CATCH_ALL_DUAL
  682. }
  683.  
  684. STDMETHODIMP CTCEventsApp::XAppEvents::PointSnapped(IDrawing* WhichDrawing, View* WhichView, long XScreen, long YScreen, IVertex* PointRaw, IVertex* PointSnapped)
  685. {
  686.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  687.  
  688.     TRY_DUAL(IID_IAppEvents)
  689.     {
  690.         pThis->PointSnapped(WhichDrawing, WhichView, XScreen, YScreen, PointRaw, PointSnapped);
  691.         return S_OK;
  692.     }
  693.     CATCH_ALL_DUAL
  694. }
  695.  
  696. STDMETHODIMP CTCEventsApp::XAppEvents::PointPick(IDrawing* WhichDrawing, View* WhichView, PickResult* Pick, IMSI_BOOL WasCanceled)
  697. {
  698.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  699.  
  700.     TRY_DUAL(IID_IAppEvents)
  701.     {
  702.         pThis->PointPick(WhichDrawing, WhichView, Pick, WasCanceled);
  703.         return S_OK;
  704.     }
  705.     CATCH_ALL_DUAL
  706. }
  707.  
  708. STDMETHODIMP CTCEventsApp::XAppEvents::RectanglePick(IDrawing* WhichDrawing, View* WhichView, PickResult* Pick, IMSI_BOOL WasCanceled)
  709. {
  710.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  711.  
  712.     TRY_DUAL(IID_IAppEvents)
  713.     {
  714.         pThis->RectanglePick(WhichDrawing, WhichView, Pick, WasCanceled);
  715.         return S_OK;
  716.     }
  717.     CATCH_ALL_DUAL
  718. }
  719.  
  720. STDMETHODIMP CTCEventsApp::XAppEvents::PolygonPick(IDrawing* WhichDrawing, View* WhichView, PickResult* Pick, IMSI_BOOL WasCanceled)
  721. {
  722.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  723.  
  724.     TRY_DUAL(IID_IAppEvents)
  725.     {
  726.         pThis->PolygonPick(WhichDrawing, WhichView, Pick, WasCanceled);
  727.         return S_OK;
  728.     }
  729.     CATCH_ALL_DUAL
  730. }
  731.  
  732. STDMETHODIMP CTCEventsApp::XAppEvents::ViewBeforeRedraw(IDrawing* WhichDrawing, View* WhichView)
  733. {
  734.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  735.  
  736.     TRY_DUAL(IID_IAppEvents)
  737.     {
  738.         pThis->ViewBeforeRedraw(WhichDrawing, WhichView);
  739.         return S_OK;
  740.     }
  741.     CATCH_ALL_DUAL
  742. }
  743.  
  744. STDMETHODIMP CTCEventsApp::XAppEvents::ViewAfterRedraw(IDrawing* WhichDrawing, View* WhichView)
  745. {
  746.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  747.  
  748.     TRY_DUAL(IID_IAppEvents)
  749.     {
  750.         pThis->ViewAfterRedraw(WhichDrawing, WhichView);
  751.         return S_OK;
  752.     }
  753.     CATCH_ALL_DUAL
  754. }
  755.  
  756. STDMETHODIMP CTCEventsApp::XAppEvents::VirtualIntersectionPick(IDrawing* WhichDrawing, View* WhichView, PickResult* Pick, IMSI_BOOL WasCanceled)
  757. {
  758.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  759.  
  760.     TRY_DUAL(IID_IAppEvents)
  761.     {
  762.         pThis->VirtualIntersectionPick(WhichDrawing, WhichView, Pick, WasCanceled);
  763.         return S_OK;
  764.     }
  765.     CATCH_ALL_DUAL
  766. }
  767.  
  768. STDMETHODIMP CTCEventsApp::XAppEvents::CommandBarControlDone(CommandBarControl* WhichControl)
  769. {
  770.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  771.  
  772.     TRY_DUAL(IID_IAppEvents)
  773.     {
  774.         pThis->CommandBarControlDone(WhichControl);
  775.         return S_OK;
  776.     }
  777.     CATCH_ALL_DUAL
  778. }
  779.  
  780. STDMETHODIMP CTCEventsApp::XAppEvents::Drop(IDrawing* WhichDrawing, View* WhichView, Window* WhichWindow, Selection* Sel)
  781. {
  782.     METHOD_PROLOGUE(CTCEventsApp, AppEvents)
  783.  
  784.     TRY_DUAL(IID_IAppEvents)
  785.     {
  786.         pThis->Drop(WhichDrawing, WhichView, WhichWindow, Sel);
  787.         return S_OK;
  788.     }
  789.     CATCH_ALL_DUAL
  790. }
  791.  
  792. // Implement ISupportErrorInfo to indicate we support the 
  793. // OLE Automation error handler.
  794. IMPLEMENT_DUAL_ERRORINFO(CTCEventsApp, IID_IAppEvents)
  795.  
  796. // DUAL_SUPPORT_END
  797.  
  798.  
  799.